TypeScripti testimine: tüübiohutud testide implementeerimise strateegiad robustse koodi jaoks

Tarkvaraarenduse valdkonnas on koodi kvaliteedi tagamine esmatähtis. TypeScript oma tugeva tüübisüsteemiga pakub ainulaadset võimalust luua usaldusväärsemaid ja hooldatavamaid rakendusi. See artikkel süveneb erinevatesse TypeScripti testimisstrateegiatesse, rõhutades, kuidas kasutada tüübiohutust robustsete ja tõhusate testide loomiseks. Uurime erinevaid testimisviise, raamistikke ja parimaid praktikaid, pakkudes teile põhjalikku juhendit TypeScripti testimise kohta.

Miks on tüübiohutus testimisel oluline

TypeScripti staatiline tüübisüsteem pakub testimisel mitmeid eeliseid:

• Varajane veadetektsioon: TypeScript suudab tüübipõhised vead tabada juba arenduse käigus, vähendades käitusaja rikete tõenäosust.
• Parem koodi hooldatavus: Tüübid muudavad koodi lihtsamini mõistetavaks ja refaktoreeritavaks, viies hooldatavamate testideni.
• Parem testide katvus: Tüübiteave saab juhendada põhjalikumate ja sihipärasemate testide loomist.
• Vähendatud silumisaeg: Tüübivigu on lihtsam diagnoosida ja parandada võrreldes käitusaja vigadega.

Testimise tasemed: põhjalik ülevaade

Robustne testimisstrateegia hõlmab mitut testimise taset, et tagada põhjalik katvus. Need tasemed hõlmavad:

• Ühiktestimine: Üksikute komponentide või funktsioonide testimine isolatsioonis.
• Integratsioonitestimine: Erinevate ühikute või moodulite vahelise interaktsiooni testimine.
• Otsast lõpuni (E2E) testimine: Kogu rakenduse töövoo testimine kasutaja vaatenurgast.

Ühiktestimine TypeScriptis: komponenditaseme usaldusväärsuse tagamine

Ühiktestimise raamistiku valimine

TypeScripti jaoks on saadaval mitu populaarset ühiktestimise raamistikku, sealhulgas:

• Jest: Põhjalik testimisraamistik sisseehitatud funktsioonidega, nagu pilkamine (mocking), koodi katvus ja hetktõmmise testimine. See on tuntud oma kasutusmugavuse ja suurepärase jõudluse poolest.
• Mocha: Paindlik ja laiendatav testimisraamistik, mis nõuab lisateeke funktsioonide jaoks, nagu väited (assertion) ja pilkamine.
• Jasmine: Teine populaarne testimisraamistik puhta ja loetava süntaksiga.

Selles artiklis kasutame eelkõige Jesti selle lihtsuse ja põhjalike funktsioonide tõttu. Kuid arutletud põhimõtted kehtivad ka teiste raamistike puhul.

Näide: TypeScripti funktsiooni ühiktestimine

Vaatleme järgmist TypeScripti funktsiooni, mis arvutab soodustuse summa:

            // src/discountCalculator.ts
export function calculateDiscount(price: number, discountPercentage: number): number {
  if (price < 0 || discountPercentage < 0 || discountPercentage > 100) {
    throw new Error("Invalid input: Price and discount percentage must be non-negative, and discount percentage must be between 0 and 100.");
  }
  return price * (discountPercentage / 100);
}

            

              
                Copy
              
            
          

Siin on, kuidas saate selle funktsiooni jaoks ühiktesti kirjutada, kasutades Jesti:

            // test/discountCalculator.test.ts
import { calculateDiscount } from '../src/discountCalculator';

describe('calculateDiscount', () => {
  it('should calculate the discount amount correctly', () => {
    expect(calculateDiscount(100, 10)).toBe(10);
    expect(calculateDiscount(50, 20)).toBe(10);
    expect(calculateDiscount(200, 5)).toBe(10);
  });

  it('should handle zero discount percentage correctly', () => {
    expect(calculateDiscount(100, 0)).toBe(0);
  });

  it('should handle 100% discount correctly', () => {
    expect(calculateDiscount(100, 100)).toBe(100);
  });

  it('should throw an error for invalid input (negative price)', () => {
    expect(() => calculateDiscount(-100, 10)).toThrowError("Invalid input: Price and discount percentage must be non-negative, and discount percentage must be between 0 and 100.");
  });

  it('should throw an error for invalid input (negative discount percentage)', () => {
    expect(() => calculateDiscount(100, -10)).toThrowError("Invalid input: Price and discount percentage must be non-negative, and discount percentage must be between 0 and 100.");
  });

  it('should throw an error for invalid input (discount percentage > 100)', () => {
    expect(() => calculateDiscount(100, 110)).toThrowError("Invalid input: Price and discount percentage must be non-negative, and discount percentage must be between 0 and 100.");
  });
});

            

              
                Copy
              
            
          

See näide demonstreerib, kuidas TypeScripti tüübisüsteem aitab tagada, et funktsioonile edastatakse õiged andmetüübid ja et testid katavad erinevaid stsenaariume, sealhulgas äärejuhtumeid ja veaolukordi.

TypeScripti tüüpide ärakasutamine ühiktestides

TypeScripti tüübisüsteemi saab kasutada ühiktestide selguse ja hooldatavuse parandamiseks. Näiteks saate kasutada liideseid, et määratleda funktsioonide poolt tagastatavate objektide oodatav struktuur:

            interface User {
  id: number;
  name: string;
  email: string;
}

function getUser(id: number): User {
  // ... implementation ...
  return { id: id, name: "John Doe", email: "john.doe@example.com" };
}

it('should return a user object with the correct properties', () => {
  const user = getUser(123);
  expect(user.id).toBe(123);
  expect(user.name).toBe('John Doe');
  expect(user.email).toBe('john.doe@example.com');
});

            

              
                Copy
              
            
          

Kasutades `User` liidest, tagate, et test kontrollib õigeid omadusi ja tüüpe, muutes selle robustsemaks ja vähem veaohtlikuks.

Pilkamine (Mocking) ja kännufunktsioonide kasutamine (Stubbing) TypeScriptiga

Ühiktestimisel on sageli vaja isoleerida testitav ühik, pilgates (mocking) või kasutades kännufunktsioone (stubbing) selle sõltuvuste jaoks. TypeScripti tüübisüsteem aitab tagada, et pilked ja kännud on korrektselt implementeeritud ning et need vastavad oodatavatele liidesetele.

Vaatleme funktsiooni, mis sõltub välisest teenusest andmete hankimiseks:

            interface DataService {
  getData(id: number): Promise;
}

class MyComponent {
  constructor(private dataService: DataService) {}

  async fetchData(id: number): Promise {
    return this.dataService.getData(id);
  }
}

            

              
                Copy
              
            
          

Kompomendi `MyComponent` testimiseks saate luua `DataService` pilkeimplementatsiooni:

            class MockDataService implements DataService {
  getData(id: number): Promise {
    return Promise.resolve(`Data for id ${id}`);
  }
}

it('should fetch data from the data service', async () => {
  const mockDataService = new MockDataService();
  const component = new MyComponent(mockDataService);
  const data = await component.fetchData(123);
  expect(data).toBe('Data for id 123');
});

            

              
                Copy
              
            
          

Implementeerides `DataService` liidese, tagab `MockDataService`, et see pakub nõutavaid meetodeid õigete tüüpidega, vältides testimise käigus tüübipõhiseid vigu.

Integratsioonitestimine TypeScriptis: moodulitevaheliste interaktsioonide kontrollimine

Integratsioonitestimine keskendub erinevate ühikute või moodulite vaheliste interaktsioonide kontrollimisele rakenduse sees. See testimise tase on ülioluline tagamaks, et süsteemi erinevad osad töötavad korrektselt koos.

Näide: integratsioonitestimine andmebaasiga

Vaatleme rakendust, mis suhtleb andmebaasiga andmete salvestamiseks ja hankimiseks. Selle rakenduse integratsioonitest võib hõlmata:

• Testandmebaasi seadistamine.
• Andmebaasi täitmine testandmetega.
• Andmebaasiga suhtleva rakenduse koodi käivitamine.
• Andmete korrektse salvestamise ja hankimise kontrollimine.
• Testandmebaasi puhastamine pärast testi lõppu.

            // integration/userRepository.test.ts
import { UserRepository } from '../src/userRepository';
import { DatabaseConnection } from '../src/databaseConnection';

describe('UserRepository', () => {
  let userRepository: UserRepository;
  let databaseConnection: DatabaseConnection;

  beforeAll(async () => {
    databaseConnection = new DatabaseConnection('test_database'); // Use a separate test database
    await databaseConnection.connect();
    userRepository = new UserRepository(databaseConnection);
  });

  afterAll(async () => {
    await databaseConnection.disconnect();
  });

  beforeEach(async () => {
    // Clear the database before each test
    await databaseConnection.clearDatabase();
  });

  it('should create a new user in the database', async () => {
    const newUser = { id: 1, name: 'Alice', email: 'alice@example.com' };
    await userRepository.createUser(newUser);

    const retrievedUser = await userRepository.getUserById(1);
    expect(retrievedUser).toEqual(newUser);
  });

  it('should retrieve a user from the database by ID', async () => {
    const existingUser = { id: 2, name: 'Bob', email: 'bob@example.com' };
    await userRepository.createUser(existingUser);

    const retrievedUser = await userRepository.getUserById(2);
    expect(retrievedUser).toEqual(existingUser);
  });
});

            

              
                Copy
              
            
          

See näide demonstreerib, kuidas seadistada testkeskkond, suhelda andmebaasiga ja kontrollida, kas rakenduse kood salvestab ja hangib andmeid korrektselt. TypeScripti liideste kasutamine andmebaasi entiteetide jaoks (nt `User`) tagab tüübiohutuse kogu integratsioonitestimise protsessi vältel.

Väliste teenuste pilkamine integratsioonitestides

Integratsioonitestides on sageli vaja pilgata väliseid teenuseid, millest rakendus sõltub. See võimaldab teil testida rakenduse ja teenuse vahelist integratsiooni, ilma et peaksite teenusest endast sõltuma.

Näiteks kui teie rakendus integreerub makseväravaga, saate luua värava pilkeimplementatsiooni erinevate maksetsenaariumite simuleerimiseks.

Otsast lõpuni (E2E) testimine TypeScriptis: kasutajate töövoogude simuleerimine

Otsast lõpuni (E2E) testimine hõlmab kogu rakenduse töövoo testimist kasutaja vaatenurgast. Seda tüüpi testimine on ülioluline tagamaks, et rakendus töötab korrektselt reaalses keskkonnas.

E2E testimise raamistiku valimine

TypeScripti jaoks on saadaval mitu populaarset E2E testimise raamistikku, sealhulgas:

• Cypress: Võimas ja kasutajasõbralik E2E testimise raamistik, mis võimaldab kirjutada teste, mis simuleerivad kasutaja interaktsioone rakendusega.
• Playwright: Veebilehitsejaülene testimise raamistik, mis toetab mitut programmeerimiskeelt, sealhulgas TypeScripti.
• Puppeteer: Node'i teek, mis pakub kõrgetasemelist API-t peata Chrome'i või Chromiumi kontrollimiseks.

Cypress sobib eriti hästi veebirakenduste E2E testimiseks tänu oma kasutusmugavusele ja põhjalikele funktsioonidele. Playwright on suurepärane veebilehitsejaülese ühilduvuse ja arenenud funktsioonide jaoks. Me demonstreerime E2E testimise kontseptsioone, kasutades Cypressi.

Näide: E2E testimine Cypressiga

Vaatleme lihtsat veebirakendust sisselogimisvormiga. Selle rakenduse E2E test võib hõlmata:

• Sisselogimislehe külastamist.
• Kehtivate volituste sisestamist.
• Vormi esitamist.
• Kontrollimist, et kasutaja suunatakse ümber avalehele.

            // cypress/integration/login.spec.ts
describe('Login', () => {
  it('should log in successfully with valid credentials', () => {
    cy.visit('/login');
    cy.get('#username').type('valid_user');
    cy.get('#password').type('valid_password');
    cy.get('button[type=\"submit\"]').click();
    cy.url().should('include', '/home');
    cy.contains('Welcome, valid_user').should('be.visible');
  });

  it('should display an error message with invalid credentials', () => {
    cy.visit('/login');
    cy.get('#username').type('invalid_user');
    cy.get('#password').type('invalid_password');
    cy.get('button[type=\"submit\"]').click();
    cy.contains('Invalid username or password').should('be.visible');
  });
});

            

              
                Copy
              
            
          

See näide demonstreerib, kuidas kasutada Cypressi kasutaja interaktsioonide simuleerimiseks veebirakendusega ja kontrollida, kas rakendus käitub ootuspäraselt. Cypress pakub võimsat API-t DOM-iga suhtlemiseks, väidete esitamiseks ja kasutaja sündmuste simuleerimiseks.

Tüübiohutus Cypressi testides

Kuigi Cypress on eelkõige JavaScriptil põhinev raamistik, saate siiski kasutada TypeScripti, et parandada oma E2E testide tüübiohutust. Näiteks saate kasutada TypeScripti kohandatud käskude defineerimiseks ja API kõnede tagastatavate andmete tüüpimiseks.

Parimad praktikad TypeScripti testimisel

Tagamaks, et teie TypeScripti testid on tõhusad ja hooldatavad, kaaluge järgmisi parimaid praktikaid:

• Kirjutage teste varakult ja sageli: Integreerige testimine oma arendustöövoogu algusest peale. Testipõhine arendus (TDD) on suurepärane lähenemine.
• Keskenduge testitavusele: Kujundage oma kood nii, et seda oleks lihtne testida. Kasutage sõltuvussüstimist komponentide lahtiühendamiseks ja nende pilkamise lihtsustamiseks.
• Hoidke testid väikesed ja keskendunud: Iga test peaks keskenduma koodi ühele aspektile. See muudab testide mõistmise ja hooldamise lihtsamaks.
• Kasutage kirjeldavaid testinimesid: Valige testinimed, mis kirjeldavad selgelt, mida test kontrollib.
• Hoidke kõrge testide katvuse tase: Püüdke saavutada kõrge testide katvus, et tagada kõigi koodiosade piisav testimine.
• Automatiseerige oma testid: Integreerige oma testid pideva integratsiooni (CI) pipeline'i, et testid käivituksid automaatselt iga kord, kui koodis muudatusi tehakse.
• Kasutage koodi katvuse tööriistu: Kasutage tööriistu testide katvuse mõõtmiseks ja koodiosade tuvastamiseks, mis ei ole piisavalt testitud.
• Refaktoreerige teste regulaarselt: Koodi muutudes refaktoreerige oma teste, et hoida neid ajakohasena ja hooldatavana.
• Dokumenteerige oma testid: Lisage oma testidele kommentaare, et selgitada testi eesmärki ja kõiki eeldusi, mida see teeb.
• Järgige AAA mustrit: Korralda (Arrange), Tegutse (Act), Kinnita (Assert). See aitab teie teste loetavuse huvides struktureerida.

Järeldus: Robustsete rakenduste loomine tüübiohutusega TypeScripti testimise abil

TypeScripti tugev tüübisüsteem pakub võimsa aluse robustsete ja hooldatavate rakenduste loomiseks. Kasutades testimisstrateegiates tüübiohutust, saate luua usaldusväärsemaid ja tõhusamaid teste, mis tabavad vead varakult ja parandavad koodi üldist kvaliteeti. See artikkel on uurinud erinevaid TypeScripti testimisstrateegiaid, alates ühiktestimisest kuni integratsioonitestimise ja otsast lõpuni testimiseni, pakkudes teile põhjalikku juhendit TypeScripti testimise kohta. Järgides käesolevas artiklis kirjeldatud parimaid praktikaid, saate tagada, et teie TypeScripti rakendused on põhjalikult testitud ja tootmiseks valmis. Põhjaliku testimislähenemise omaksvõtmine algusest peale võimaldab arendajatel kogu maailmas luua usaldusväärsemaid ja hooldatavamaid tarkvarasid, mis viib paremate kasutajakogemuste ja vähenenud arenduskuludeni. Kuna TypeScripti kasutuselevõtt jätkab kasvu, muutub tüübiohutu testimise valdamine tarkvarainseneride jaoks kogu maailmas üha väärtuslikumaks oskuseks.